home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / bash_114.zip / bash-1.14.2 / dispose_cmd.c < prev    next >
C/C++ Source or Header  |  1994-03-03  |  4KB  |  208 lines
  1. /* dispose_command.c -- dispose of a COMMAND structure. */
  2.  
  3. /* Copyright (C) 1987,1991 Free Software Foundation, Inc.
  4.  
  5.    This file is part of GNU Bash, the Bourne Again SHell.
  6.  
  7.    Bash is free software; you can redistribute it and/or modify it
  8.    under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 1, or (at your option)
  10.    any later version.
  11.  
  12.    Bash is distributed in the hope that it will be useful, but WITHOUT
  13.    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14.    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15.    License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with Bash; see the file COPYING.  If not, write to the Free
  19.    Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20.  
  21. #include "shell.h"
  22.  
  23. /* Dispose of the command structure passed. */
  24. void
  25. dispose_command (command)
  26.      COMMAND *command;
  27. {
  28.   if (!command) return;
  29.  
  30.   if (command->redirects)
  31.     dispose_redirects (command->redirects);
  32.  
  33.   switch (command->type)
  34.     {
  35.     case cm_for:
  36.       {
  37.     register FOR_COM *c = command->value.For;
  38.     dispose_word (c->name);
  39.     dispose_words (c->map_list);
  40.     dispose_command (c->action);
  41.     free (c);
  42.     break;
  43.       }
  44.  
  45. #if defined (SELECT_COMMAND)
  46.     case cm_select:
  47.       {
  48.     register SELECT_COM *c = command->value.Select;
  49.     dispose_word (c->name);
  50.     dispose_words (c->map_list);
  51.     dispose_command (c->action);
  52.     free (c);
  53.     break;
  54.       }
  55. #endif
  56.     
  57.     case cm_group:
  58.       {
  59.     dispose_command (command->value.Group->command);
  60.     free (command->value.Group);
  61.     break;
  62.       }
  63.  
  64.     case cm_case:
  65.       {
  66.     register CASE_COM *c = command->value.Case;
  67.     PATTERN_LIST *t, *p = c->clauses;
  68.  
  69.     dispose_word (c->word);
  70.  
  71.     while (p)
  72.       {
  73.         dispose_words (p->patterns);
  74.         dispose_command (p->action);
  75.         t = p;
  76.         p = p->next;
  77.         free (t);
  78.       }
  79.     free (c);
  80.     break;
  81.       }
  82.  
  83.     case cm_until:
  84.     case cm_while:
  85.       {
  86.     register WHILE_COM *c = command->value.While;
  87.  
  88.     dispose_command (c->test);
  89.     dispose_command (c->action);
  90.     free (c);
  91.     break;
  92.       }
  93.  
  94.     case cm_if:
  95.       {
  96.     register IF_COM *c = command->value.If;
  97.     dispose_command (c->test);
  98.     dispose_command (c->true_case);
  99.     dispose_command (c->false_case);
  100.     free (c);
  101.     break;
  102.       }
  103.  
  104.     case cm_simple:
  105.       {
  106.     register SIMPLE_COM *c = command->value.Simple;
  107.     dispose_words (c->words);
  108.     dispose_redirects (c->redirects);
  109.     free (c);
  110.     break;
  111.       }
  112.  
  113.     case cm_connection:
  114.       {
  115.     register CONNECTION *c = command->value.Connection;
  116.     dispose_command (c->first);
  117.     dispose_command (c->second);
  118.     free (c);
  119.     break;
  120.       }
  121.  
  122.     case cm_function_def:
  123.       {
  124.     register FUNCTION_DEF *c = command->value.Function_def;
  125.     dispose_word (c->name);
  126.     dispose_command (c->command);
  127.     free (c);
  128.     break;
  129.       }
  130.  
  131.     default:
  132.       report_error ("Attempt to free unknown command type `%d'.\n", command->type);
  133.       break;
  134.     }
  135.   free (command);
  136. }
  137.  
  138. /* How to free a WORD_DESC. */
  139. void
  140. dispose_word (word)
  141.      WORD_DESC *word;
  142. {
  143.   if (word->word)
  144.     free (word->word);
  145.   free (word);
  146. }
  147.  
  148. /* How to get rid of a linked list of words.  A WORD_LIST. */
  149. void
  150. dispose_words (list)
  151.      WORD_LIST *list;
  152. {
  153.   WORD_LIST *t;
  154.   while (list)
  155.     {
  156.       t = list;
  157.       list = list->next;
  158.       dispose_word (t->word);
  159.       free (t);
  160.     }
  161. }
  162.  
  163. /* How to dispose of an array of pointers to char. */
  164. void
  165. dispose_word_array (array)
  166.      char **array;
  167. {
  168.   register int count;
  169.  
  170.   for (count = 0; array[count]; count++)
  171.     free (array[count]);
  172.  
  173.   free (array);
  174. }
  175.  
  176. /* How to dispose of an list of redirections.  A REDIRECT. */
  177. void
  178. dispose_redirects (list)
  179.      REDIRECT *list;
  180. {
  181.   register REDIRECT *t;
  182.  
  183.   while (list)
  184.     {
  185.       t = list;
  186.       list = list->next;
  187.       switch (t->instruction)
  188.     {
  189.     case r_reading_until:
  190.     case r_deblank_reading_until:
  191.       free (t->here_doc_eof);
  192.       /* ... */
  193.     case r_output_direction:
  194.     case r_input_direction:
  195.     case r_inputa_direction:
  196.     case r_appending_to:
  197.     case r_err_and_out:
  198.     case r_input_output:
  199.     case r_output_force:
  200.     case r_duplicating_input_word:
  201.     case r_duplicating_output_word:
  202.       dispose_word (t->redirectee.filename);
  203.       break;
  204.     }
  205.       free (t);
  206.     }
  207. }
  208.